// 提醒管理工具类
import api from './api.js'

class ReminderManager {
    constructor() {
        this.reminders = new Map() // 存储所有提醒的计时器
        this.notificationQueue = [] // 提醒队列，用于顺序显示提醒
        this.isShowingNotification = false // 是否正在显示提醒
        this.isInitialized = false // 是否已经初始化
        this.eventCache = new Map() // 缓存日程数据，用于检测变更
        this.updateCheckTimer = null // 存储更新检查的定时器
        this.currentAudio = null // 存储当前播放的音频对象
    }

    // 添加日程提醒
    addEventReminder(event) {
        if (!event.id || !event.date || !event.startTime || !event.title) {
            console.error('无效的日程数据:', event)
            return
        }

        // 确保event有endTime字段
        if (!event.endTime) {
            // 如果没有结束时间，默认为开始时间后1小时
            const startParts = event.startTime.split(':');
            const startHour = parseInt(startParts[0]);
            const startMinute = parseInt(startParts[1]);
            
            let endHour = startHour + 1;
            if (endHour >= 24) endHour = 23;
            
            event.endTime = `${String(endHour).padStart(2, '0')}:${String(startMinute).padStart(2, '0')}`;
            console.log(`日程"${event.title}"没有结束时间，默认设置为: ${event.endTime}`);
        }

        // 缓存日程数据，用于检测变更
        this.eventCache.set(event.id, {...event})

        // 获取设置
        const settings = uni.getStorageSync('settings') || {
            enableNotification: true,
            reminderTime: 1, // 默认15分钟前
            notificationType: 1 // 默认声音+弹窗
        }
        
        if (!settings.enableNotification) {
            console.log('通知功能已在设置中关闭')
            return
        }

        // 构建日期时间
        const eventDateTime = this.parseDateTime(event.date, event.startTime)
        
        // 检查日程时间是否已过
        const now = new Date()
        if (eventDateTime < now) {
            console.log(`日程"${event.title}"已过期，不设置提醒`)
            return
        }
        
        // 计算提醒时间
        const reminderTime = this.calculateReminderTime(eventDateTime, settings.reminderTime)
        
        // 如果提醒时间已过但日程还未开始，立即触发提醒
        if (reminderTime <= now && eventDateTime > now) {
            console.log(`日程"${event.title}"的提醒时间已过，但日程尚未开始，立即触发提醒`)
            setTimeout(() => {
                this.triggerReminder({
                    id: 'event_' + event.id,
                    title: '日程提醒',
                    content: event.title,
                    startTime: event.startTime,
                    endTime: event.endTime,
                    date: event.date,
                    type: 'event'
                }, settings)
            }, 1000) // 1秒后触发提醒
            return
        }
        
        // 如果提醒时间和日程都已过期，不设置提醒
        if (reminderTime <= now) {
            console.log(`日程"${event.title}"的提醒时间已过`)
            return
        }

        // 计算距离提醒的时间（毫秒）
        const reminderTimeMs = reminderTime.getTime() - now.getTime()
        console.log(`设置日程"${event.title}"的提醒，将在${Math.floor(reminderTimeMs/60000)}分钟后触发（${reminderTime.toLocaleString()}）`)

        // 设置提醒ID (确保日程和任务提醒ID不冲突)
        const reminderId = 'event_' + event.id

        // 如果已经存在该提醒，先清除
        this.removeReminder(event.id, 'event')

        // 设置定时器
        const timerId = setTimeout(() => {
            this.triggerReminder({
                id: reminderId,
                title: '日程提醒',
                content: event.title,
                startTime: event.startTime,
                endTime: event.endTime,
                date: event.date,
                type: 'event'
            }, settings)
        }, reminderTimeMs)

        // 保存定时器ID
        this.reminders.set(reminderId, timerId)
    }

    // 添加任务提醒
    addTaskReminder(task) {
        if (!task.id || !task.dueDate || !task.title) {
            console.error('无效的任务数据:', task)
            return
        }

        // 如果任务已完成则不设置提醒
        if (task.completed) {
            return
        }

        // 获取设置
        const settings = uni.getStorageSync('settings') || {
            enableNotification: true,
            reminderTime: 0, // 默认5分钟前
            notificationType: 1 // 默认声音+弹窗
        }
        
        if (!settings.enableNotification) {
            console.log('通知功能已关闭')
            return
        }

        // 提取时间部分 - 支持精确到分钟
        let dueTime = "23:59"
        if (task.dueTime) {
            dueTime = task.dueTime
            console.log(`任务"${task.title}"有设置具体截止时间: ${dueTime}`)
        } else {
            console.log(`任务"${task.title}"没有设置具体截止时间，使用默认值: ${dueTime}`)
        }
        
        // 确保task有endTime字段，用于稍后提醒功能
        task.endTime = dueTime
        
        // 构建截止日期时间
        const taskDueDateTime = this.parseDateTime(task.dueDate, dueTime)
        
        // 添加两个提醒点:
        // 1. 截止时间前三天上午9点提醒
        // 2. 截止当天提醒
        
        // 计算提前三天的提醒时间
        const earlyReminderDate = new Date(taskDueDateTime)
        earlyReminderDate.setDate(earlyReminderDate.getDate() - 3) // 提前三天
        earlyReminderDate.setHours(9, 0, 0, 0) // 设置为早上9点
        
        // 当前时间
        const now = new Date()
        
        // 设置提醒ID (确保日程和任务提醒ID不冲突)
        const earlyReminderId = 'task_early_' + task.id
        const finalReminderId = 'task_final_' + task.id
        
        // 如果已经存在该提醒，先清除
        this.removeReminder(task.id, 'task_early')
        this.removeReminder(task.id, 'task_final')
        
        // 设置提前三天的提醒（如果提醒时间尚未过）
        if (earlyReminderDate > now) {
            const earlyReminderTimeMs = earlyReminderDate.getTime() - now.getTime()
            console.log(`设置任务"${task.title}"的提前提醒，将在${Math.floor(earlyReminderTimeMs/3600000)}小时后触发（${earlyReminderDate.toLocaleString()}）`)
            
            // 设置定时器
            const earlyTimerId = setTimeout(() => {
                this.triggerReminder({
                    id: earlyReminderId,
                    title: '任务提前提醒',
                    content: task.title,
                    dueDate: task.dueDate,
                    endTime: dueTime, // 使用截止时间
                    priority: task.priority,
                    type: 'task',
                    reminderType: 'early' // 标记为提前提醒
                }, settings)
            }, earlyReminderTimeMs)
            
            // 保存定时器ID
            this.reminders.set(earlyReminderId, earlyTimerId)
        } else {
            console.log(`任务"${task.title}"的提前提醒时间已过`)
        }
        
        // 设置最终截止日期的提醒（如果提醒时间尚未过）
        if (taskDueDateTime > now) {
            // 为最终提醒计算提醒时间（截止时间前30分钟或当天早上9点，以较早者为准）
            const finalReminderDate = new Date(taskDueDateTime)
            
            // 设置为截止时间前30分钟
            finalReminderDate.setMinutes(finalReminderDate.getMinutes() - 30)
            
            // 如果截止时间前30分钟尚未过
            if (finalReminderDate > now) {
                const finalReminderTimeMs = finalReminderDate.getTime() - now.getTime()
                console.log(`设置任务"${task.title}"的最终提醒，将在${Math.floor(finalReminderTimeMs/60000)}分钟后触发（${finalReminderDate.toLocaleString()}）`)
                
                // 设置定时器
                const finalTimerId = setTimeout(() => {
                    this.triggerReminder({
                        id: finalReminderId,
                        title: '任务截止提醒',
                        content: `${task.title}（即将截止）`,
                        dueDate: task.dueDate,
                        endTime: dueTime, // 使用截止时间
                        priority: task.priority,
                        type: 'task',
                        reminderType: 'final' // 标记为最终提醒
                    }, settings)
                }, finalReminderTimeMs)
                
                // 保存定时器ID
                this.reminders.set(finalReminderId, finalTimerId)
            } else {
                console.log(`任务"${task.title}"的最终提醒时间已过，但尚未截止，立即触发提醒`)
                
                // 立即触发提醒
                setTimeout(() => {
                    this.triggerReminder({
                        id: finalReminderId,
                        title: '任务截止提醒',
                        content: `${task.title}（即将截止）`,
                        dueDate: task.dueDate,
                        endTime: dueTime, // 使用截止时间
                        priority: task.priority,
                        type: 'task',
                        reminderType: 'final' // 标记为最终提醒
                    }, settings)
                }, 1000) // 1秒后触发提醒
            }
        } else {
            console.log(`任务"${task.title}"已截止，不设置提醒`)
        }
    }

    // 移除提醒
    removeReminder(id, type = '') {
        const reminderId = type ? `${type}_${id}` : id
        if (this.reminders.has(reminderId)) {
            console.log('移除提醒:', reminderId)
            clearTimeout(this.reminders.get(reminderId))
            this.reminders.delete(reminderId)
            return true
        }
        return false
    }

    // 更新日程提醒
    updateEventReminder(event) {
        this.removeReminder(event.id, 'event')
        this.addEventReminder(event)
    }

    // 更新任务提醒
    updateTaskReminder(task) {
        this.removeReminder(task.id, 'task_early')
        this.removeReminder(task.id, 'task_final')
        this.addTaskReminder(task)
    }

    // 解析日期和时间
    parseDateTime(dateStr, timeStr) {
        try {
            const date = new Date(dateStr)
            
            // 防止timeStr为undefined
            if (!timeStr) {
                console.warn('时间字符串为空，使用当前时间');
                const now = new Date();
                date.setHours(now.getHours(), now.getMinutes(), 0, 0);
                return date;
            }
            
            const [hours, minutes] = timeStr.split(':').map(Number)
            date.setHours(hours, minutes, 0, 0)
            return date
        } catch (error) {
            console.error('Error parsing date/time:', error, 'dateStr:', dateStr, 'timeStr:', timeStr)
            return new Date() // 返回当前时间作为默认值
        }
    }

    // 计算提醒时间
    calculateReminderTime(eventTime, reminderType) {
        // 创建一个新的日期对象，避免修改原始对象
        const eventDate = new Date(eventTime.getTime())
        
        switch (reminderType) {
            case 0: // 5分钟前
                return new Date(eventDate.getTime() - 5 * 60 * 1000)
            case 1: // 15分钟前
                return new Date(eventDate.getTime() - 15 * 60 * 1000)
            case 2: // 30分钟前
                return new Date(eventDate.getTime() - 30 * 60 * 1000)
            case 3: // 1小时前
                return new Date(eventDate.getTime() - 60 * 60 * 1000)
            case 4: // 1天前
                return new Date(eventDate.getTime() - 24 * 60 * 60 * 1000)
            default:
                return new Date(eventDate.getTime() - 15 * 60 * 1000) // 默认15分钟前
        }
    }

    // 触发提醒
    triggerReminder(reminder, settings) {
        try {
            // 检查事件是否已经结束
            if (reminder.type === 'event' || reminder.type === 'task') {
                // 确保reminder有endTime字段
                if (!reminder.endTime) {
                    if (reminder.type === 'event' && reminder.startTime) {
                        // 日程默认结束时间为开始时间后1小时
                        try {
                            const startParts = reminder.startTime.split(':');
                            const startHour = parseInt(startParts[0]);
                            const startMinute = parseInt(startParts[1]);
                            
                            let endHour = startHour + 1;
                            if (endHour >= 24) endHour = 23;
                            
                            reminder.endTime = `${String(endHour).padStart(2, '0')}:${String(startMinute).padStart(2, '0')}`;
                        } catch (e) {
                            console.error('设置默认结束时间失败，使用23:59:', e);
                            reminder.endTime = "23:59";
                        }
                    } else {
                        // 任务默认结束时间为当天23:59
                        reminder.endTime = "23:59";
                    }
                    console.log(`${reminder.type === 'event' ? '日程' : '任务'}"${reminder.content || reminder.title}"没有结束时间，默认设置为: ${reminder.endTime}`);
                }
                
                const eventEndTime = this.parseDateTime(reminder.date || reminder.dueDate, reminder.endTime);
                if (new Date() >= eventEndTime) {
                    console.log(`${reminder.type === 'event' ? '日程' : '任务'}已结束，不再提醒:`, reminder.content || reminder.title);
                    this.removeReminder(reminder.id, reminder.type);
                    return;
                }
            }
            
            // 播放提醒音效
            if (settings.notificationType !== 2) { // 如果不是仅弹窗提醒，播放音效
                this.playReminderSound();
            }
            
            // 显示提醒通知
            this.showNextNotification(settings, reminder);
        } catch (error) {
            console.error('触发提醒时出错:', error);
            
            // 即使出错也尝试显示通知和播放声音
            try {
                this.showNextNotification(settings, reminder);
                if (settings.notificationType !== 2) {
                    this.playReminderSound();
                }
            } catch (e) {
                console.error('尝试恢复出错的提醒失败:', e);
            }
        }
    }

    // 停止所有音频播放
    stopAudio() {
        if (this.currentAudio) {
            try {
                console.log('停止当前音频播放');
                this.currentAudio.stop();
                this.currentAudio.destroy();
                this.currentAudio = null;
            } catch (e) {
                console.error('停止音频播放失败:', e);
            }
        }
    }
    
    // 显示下一个通知
    showNextNotification(settings, reminder) {
        try {
            console.log('显示提醒通知:', reminder.content || reminder.title);
            
            // 处理内容和时间
            let content = reminder.content || reminder.title || '未命名提醒';
            
            // 提醒内容
            let title = reminder.title || (reminder.type === 'event' ? '日程提醒' : '任务提醒');
            
            // 如果是事件，添加时间信息
            if (reminder.type === 'event') {
                const startTime = reminder.startTime || '未设置';
                const endTime = reminder.endTime || '未设置';
                content += `\n时间：${startTime} - ${endTime}`;
            }
            
            // 如果是任务，添加优先级和截止日期
            if (reminder.type === 'task') {
                const priorityText = this.getPriorityText(reminder.priority);
                content += `\n优先级：${priorityText}`;
                
                // 显示截止日期和时间
                const dueDate = reminder.dueDate || '未设置';
                const dueTime = reminder.endTime || '23:59';
                content += `\n截止时间：${dueDate} ${dueTime}`;
                
                // 根据提醒类型添加不同的说明
                if (reminder.reminderType === 'early') {
                    content += '\n（提前三天提醒）';
                } else if (reminder.reminderType === 'final') {
                    content += '\n（截止当天提醒）';
                }
            }
            
            uni.showModal({
                title: title,
                content: content,
                showCancel: true,
                cancelText: '稍后提醒',
                confirmText: '知道了',
                success: (res) => {
                    // 无论点击哪个按钮，都立即停止音频播放
                    this.stopAudio();
                    
                    if (res.confirm) {
                        // 用户点击"知道了"，不再提醒
                        console.log('用户已确认提醒');
                    } else if (res.cancel) {
                        // 用户点击"稍后提醒"，5分钟后再次提醒
                        console.log('用户选择稍后提醒，5分钟后再次提醒');
                        this.scheduleRemindLater(reminder, settings);
                    }
                }
            });
        } catch (error) {
            console.error('显示通知失败:', error);
            // 出错时也尝试停止音频
            this.stopAudio();
        }
    }
    
    // 安排稍后提醒
    scheduleRemindLater(reminder, settings) {
        try {
            // 计算5分钟后的时间
            const fiveMinutesLater = new Date(new Date().getTime() + 5 * 60 * 1000);
            
            // 对于事件或任务，确保再次提醒时间小于结束时间
            if (reminder.type === 'event' || reminder.type === 'task') {
                // 确保reminder有正确的日期字段
                const dateField = reminder.type === 'event' ? reminder.date : reminder.dueDate;
                
                // 确保reminder有endTime字段
                if (!reminder.endTime) {
                    if (reminder.type === 'event') {
                        // 日程默认结束时间为开始时间后1小时
                        const startParts = reminder.startTime.split(':');
                        const startHour = parseInt(startParts[0]);
                        const startMinute = parseInt(startParts[1]);
                        
                        let endHour = startHour + 1;
                        if (endHour >= 24) endHour = 23;
                        
                        reminder.endTime = `${String(endHour).padStart(2, '0')}:${String(startMinute).padStart(2, '0')}`;
                    } else {
                        // 任务默认结束时间为当天23:59
                        reminder.endTime = "23:59";
                    }
                    console.log(`${reminder.type === 'event' ? '日程' : '任务'}"${reminder.title}"没有结束时间，默认设置为: ${reminder.endTime}`);
                }
                
                const endTime = this.parseDateTime(dateField, reminder.endTime);
                
                // 如果5分钟后已经超过了结束时间，则不再设置提醒
                if (fiveMinutesLater >= endTime) {
                    console.log(`无法设置稍后提醒：5分钟后已超过${reminder.type === 'event' ? '日程' : '任务'}结束时间`);
                    uni.showToast({
                        title: `已接近${reminder.type === 'event' ? '日程' : '任务'}结束时间，不再提醒`,
                        icon: 'none',
                        duration: 2000
                    });
                    return;
                }
            }
            
            // 设置定时器，延迟5分钟后再次触发提醒
            setTimeout(() => {
                console.log('执行稍后提醒:', reminder.title);
                this.triggerReminder(reminder, settings);
            }, 5 * 60 * 1000);
            
            // 提示用户稍后提醒已设置
            uni.showToast({
                title: '已设置5分钟后提醒',
                icon: 'none',
                duration: 2000
            });
        } catch (error) {
            console.error('设置稍后提醒失败:', error);
        }
    }

    // 播放提醒音效
    playReminderSound() {
        // 先停止可能存在的音频播放
        this.stopAudio();
        
        try {
            console.log('开始播放提醒音效...');
            const innerAudioContext = uni.createInnerAudioContext();
            
            // 保存音频实例以便后续停止
            this.currentAudio = innerAudioContext;
            
            // 设置音频路径
            let mainSoundPath;
            
            // #ifdef APP-PLUS
            mainSoundPath = 'static/sound/reminder.mp3'; // App 环境不需要前导斜杠
            // #endif
            
            // #ifdef H5 || MP-WEIXIN || MP-ALIPAY || MP-BAIDU || MP-TOUTIAO || MP-QQ
            mainSoundPath = '/static/sound/reminder.mp3'; // H5和小程序环境需要前导斜杠
            // #endif
            
            // 如果条件编译没有生效，使用默认路径
            if (!mainSoundPath) {
                mainSoundPath = '/static/sound/reminder.mp3';
            }
            
            console.log('当前平台的音频路径:', mainSoundPath);
            
            // 添加音频事件监听
            innerAudioContext.onCanplay(() => {
                console.log('音频已加载，准备播放');
                // 尝试主动触发播放
                try {
                    innerAudioContext.play();
                    console.log('主动触发音频播放');
                } catch (e) {
                    console.error('主动触发播放失败:', e);
                }
            });
            
            innerAudioContext.onPlay(() => {
                console.log('音频开始播放');
            });
            
            innerAudioContext.onStop(() => {
                console.log('音频播放停止');
            });
            
            innerAudioContext.onPause(() => {
                console.log('音频播放暂停');
            });
            
            // 设置音频源
            innerAudioContext.src = mainSoundPath;
            
            // 设置音量确保可以听到
            innerAudioContext.volume = 1.0;
            
            // 设置自动播放
            innerAudioContext.autoplay = true;
            
            // 强制触发播放
            setTimeout(() => {
                try {
                    if (this.currentAudio === innerAudioContext) {
                        console.log('延迟后再次尝试播放音频');
                        innerAudioContext.play();
                    }
                } catch (e) {
                    console.error('延迟触发播放失败:', e);
                }
            }, 300);
            
            // 音频播放完成后释放资源
            innerAudioContext.onEnded(() => {
                console.log('提示音播放完成');
                if (this.currentAudio === innerAudioContext) {
                    this.currentAudio = null;
                }
                innerAudioContext.destroy();
            });
            
            // 处理播放错误
            innerAudioContext.onError((res) => {
                console.error('主要提示音播放失败:', res.errMsg, res.errCode);
                // 尝试播放备用提示音
                this.tryBackupSounds();
            });
        } catch (error) {
            console.error('播放提醒音效失败:', error);
            this.playFallbackSound();
        }
    }
    
    // 尝试播放备用提示音
    tryBackupSounds() {
        try {
            console.log('尝试播放备用提示音...');
            const innerAudioContext = uni.createInnerAudioContext();
            
            // 设置备用音效路径
            let backupSoundPath;
            
            // #ifdef APP-PLUS
            backupSoundPath = 'static/sound/alert.mp3';
            // #endif
            
            // #ifdef H5 || MP-WEIXIN || MP-ALIPAY || MP-BAIDU || MP-TOUTIAO || MP-QQ
            backupSoundPath = '/static/sound/alert.mp3';
            // #endif
            
            // 如果条件编译没有生效，使用默认路径
            if (!backupSoundPath) {
                backupSoundPath = '/static/sound/alert.mp3';
            }
            
            // 设置音频源
            innerAudioContext.src = backupSoundPath;
            innerAudioContext.autoplay = true;
            
            // 处理播放错误，尝试系统提示音
            innerAudioContext.onError(() => {
                console.log('备用提示音播放失败，使用系统音效');
                this.playSystemSound();
            });
            
            innerAudioContext.onEnded(() => {
                innerAudioContext.destroy();
            });
        } catch (error) {
            console.error('播放备用提示音失败:', error);
            this.playSystemSound();
        }
    }
    
    // 尝试播放系统提示音
    playSystemSound() {
        try {
            console.log('尝试播放系统提示音...');
            
            // #ifdef APP-PLUS
            // 在App环境下使用plus提供的系统音效
            if (window.plus && plus.audio) {
                plus.audio.playSystemSound(plus.audio.SoundType.NOTIFY);
                return;
            }
            // #endif
            
            // 如果没有系统提示音功能，使用震动
            this.playFallbackSound();
        } catch (error) {
            console.error('播放系统提示音失败:', error);
            this.playFallbackSound();
        }
    }
    
    // 播放备用声音 (使用uni-app提供的系统声音)
    playFallbackSound() {
        try {
            console.log('使用系统震动作为最终备用提醒方式');
            // 使用震动作为备用提醒方式
            uni.vibrateLong({
                success: function () {
                    console.log('震动提醒成功');
                },
                fail: function(err) {
                    console.error('震动提醒失败', err);
                }
            });
        } catch(e) {
            console.error('备用提醒方式也失败了:', e);
        }
    }

    // 获取优先级文本
    getPriorityText(priority) {
        const priorities = ['低', '中', '高']
        return priorities[priority] || '中'
    }

    // 初始化所有提醒
    initializeReminders() {
        if (this.isInitialized) {
            return
        }
        
        console.log('初始化提醒系统...')
        this.isInitialized = true
        
        // 清除可能存在的旧提醒
        this.clearAllReminders()
        
        // 初始化日程提醒
        this.initializeEventReminders()
        
        // 初始化任务提醒
        this.initializeTaskReminders()
        
        // 设置定期检查更新
        this.setupUpdateCheck()
    }
    
    // 设置定期检查更新
    setupUpdateCheck() {
        // 先清除可能存在的旧定时器
        if (this.updateCheckTimer) {
            clearInterval(this.updateCheckTimer)
        }
        
        // 设置每5分钟检查一次更新
        this.updateCheckTimer = setInterval(() => {
            console.log('定期检查日程和任务更新...')
            this.checkForUpdates()
        }, 5 * 60 * 1000) // 5分钟
        
        console.log('已设置定期检查机制，每5分钟检查一次')
    }
    
    // 检查更新
    checkForUpdates() {
        try {
            // 获取当前日期和未来7天的日期范围
            const today = new Date()
            const endDate = new Date(today)
            endDate.setDate(endDate.getDate() + 7) // 获取一周内的日程
            
            const formattedStartDate = this.formatDate(today)
            const formattedEndDate = this.formatDate(endDate)
            
            // 从后端API获取最新日程
            api.getEvents(formattedStartDate, formattedEndDate)
                .then(response => {
                    if (response.code === 200 && response.data) {
                        const eventList = response.data
                        console.log(`检查更新: 获取到${eventList.length}个日程`)
                        
                        // 处理每个日程
                        eventList.forEach(event => {
                            // 检查日程是否存在于缓存中
                            const cachedEvent = this.eventCache.get(event.id)
                            
                            // 如果不存在或者有变更，则更新提醒
                            if (!cachedEvent || 
                                cachedEvent.date !== event.date || 
                                cachedEvent.startTime !== event.startTime) {
                                
                                console.log(`日程"${event.title}"已更新，重新设置提醒`)
                                this.addEventReminder(event)
                            }
                        })
                        
                        // 检查已删除的日程
                        this.eventCache.forEach((cachedEvent, eventId) => {
                            // 如果缓存中的日程不在最新列表中，说明已被删除
                            const stillExists = eventList.some(e => e.id === eventId)
                            if (!stillExists) {
                                console.log(`日程ID:${eventId}已被删除，移除对应提醒`)
                                this.removeReminder(eventId, 'event')
                                this.eventCache.delete(eventId)
                            }
                        })
                        
                        // 保存到本地存储
                        uni.setStorageSync('events', JSON.stringify(eventList))
                    }
                })
                .catch(error => {
                    console.error('检查日程更新失败:', error)
                })
                
            // 同样检查任务更新
            api.getTasks()
                .then(response => {
                    if (response.code === 200 && response.data) {
                        const taskList = response.data
                        console.log(`检查更新: 获取到${taskList.length}个任务`)
                        
                        // 更新任务提醒 (简化版，不做详细比较)
                        taskList.forEach(task => {
                            if (!task.completed) {
                                this.updateTaskReminder(task)
                            } else {
                                // 如果任务已完成，移除对应提醒
                                this.removeReminder(task.id, 'task_early')
                                this.removeReminder(task.id, 'task_final')
                            }
                        })
                        
                        // 保存到本地存储
                        uni.setStorageSync('tasks', JSON.stringify(taskList))
                    }
                })
                .catch(error => {
                    console.error('检查任务更新失败:', error)
                })
                
        } catch (error) {
            console.error('检查更新过程中出错:', error)
        }
    }
    
    // 初始化日程提醒 - 修改为从后端获取当天及未来日程数据
    initializeEventReminders() {
        try {
            // 获取当前日期和未来7天的日期范围
            const today = new Date()
            const endDate = new Date(today)
            endDate.setDate(endDate.getDate() + 7) // 获取一周内的日程
            
            const formattedStartDate = this.formatDate(today)
            const formattedEndDate = this.formatDate(endDate)
            
            console.log(`正在获取从${formattedStartDate}到${formattedEndDate}的日程数据...`)
            
            // 从后端API获取日程
            api.getEvents(formattedStartDate, formattedEndDate)
                .then(response => {
                    if (response.code === 200 && response.data) {
                        const eventList = response.data
                        console.log(`从后端获取到${eventList.length}个日程`)
                        
                        // 设置每个日程的提醒
                        eventList.forEach(event => {
                            this.addEventReminder(event)
                        })
                        
                        // 保存到本地存储
                        uni.setStorageSync('events', JSON.stringify(eventList))
                        
                        // 检查当天的日程，对于即将开始的日程，确保设置了提醒
                        this.checkForImmediateEvents(eventList)
                    } else {
                        console.error('获取日程数据失败:', response.message)
                    }
                })
                .catch(error => {
                    console.error('获取日程数据异常:', error)
                    
                    // 如果API调用失败，尝试使用本地缓存
                    this.initializeFromLocalStorage()
                })
        } catch (error) {
            console.error('初始化日程提醒失败:', error)
            // 出错时尝试从本地存储初始化
            this.initializeFromLocalStorage()
        }
    }
    
    // 检查即将开始的日程
    checkForImmediateEvents(eventList) {
        if (!eventList || eventList.length === 0) return
        
        const now = new Date()
        const settings = uni.getStorageSync('settings') || {
            enableNotification: true,
            reminderTime: 1,
            notificationType: 1
        }
        
        // 筛选今天即将开始的日程（30分钟内的）
        eventList.forEach(event => {
            try {
                const eventDate = new Date(event.date)
                const today = new Date()
                
                // 只检查今天的日程
                if (eventDate.getDate() === today.getDate() && 
                    eventDate.getMonth() === today.getMonth() && 
                    eventDate.getFullYear() === today.getFullYear()) {
                    
                    const eventDateTime = this.parseDateTime(event.date, event.startTime)
                    const timeDiff = eventDateTime.getTime() - now.getTime()
                    
                    // 如果日程将在30分钟内开始，且尚未过期
                    if (timeDiff > 0 && timeDiff <= 30 * 60 * 1000) {
                        console.log(`日程"${event.title}"将在${Math.floor(timeDiff/60000)}分钟后开始，确保设置提醒`)
                        
                        // 移除可能存在的旧提醒
                        this.removeReminder(event.id, 'event')
                        
                        // 确保event有endTime字段
                        if (!event.endTime) {
                            // 如果没有结束时间，默认为开始时间后1小时
                            const startParts = event.startTime.split(':');
                            const startHour = parseInt(startParts[0]);
                            const startMinute = parseInt(startParts[1]);
                            
                            let endHour = startHour + 1;
                            if (endHour >= 24) endHour = 23;
                            
                            event.endTime = `${String(endHour).padStart(2, '0')}:${String(startMinute).padStart(2, '0')}`;
                            console.log(`日程"${event.title}"没有结束时间，默认设置为: ${event.endTime}`);
                        }
                        
                        // 设置立即提醒
                        setTimeout(() => {
                            this.triggerReminder({
                                id: 'event_' + event.id,
                                title: '即将开始的日程',
                                content: event.title,
                                startTime: event.startTime,
                                endTime: event.endTime,
                                date: event.date,
                                type: 'event'
                            }, settings)
                        }, 2000) // 2秒后触发提醒
                    }
                }
            } catch (e) {
                console.error('检查即时日程出错:', e)
            }
        })
    }
    
    // 初始化任务提醒 - 修改为从后端获取任务数据
    initializeTaskReminders() {
        try {
            console.log('正在获取任务数据...')
            
            // 从后端API获取所有任务
            api.getTasks()
                .then(response => {
                    if (response.code === 200 && response.data) {
                        const taskList = response.data
                        console.log(`从后端获取到${taskList.length}个任务`)
                        
                        // 设置每个未完成任务的提醒
                        taskList.forEach(task => {
                            if (!task.completed) {
                                this.addTaskReminder(task)
                            }
                        })
                        
                        // 保存到本地存储
                        uni.setStorageSync('tasks', JSON.stringify(taskList))
                    } else {
                        console.error('获取任务数据失败:', response.message)
                    }
                })
                .catch(error => {
                    console.error('获取任务数据异常:', error)
                    
                    // 如果API调用失败，尝试使用本地缓存
                    this.initializeFromLocalStorage()
                })
        } catch (error) {
            console.error('初始化任务提醒失败:', error)
            // 出错时尝试从本地存储初始化
            this.initializeFromLocalStorage()
        }
    }

    // 从本地存储初始化提醒（作为后备方案）
    initializeFromLocalStorage() {
        console.log('正在从本地存储初始化提醒...')
        
        // 初始化日程提醒
        try {
            const events = uni.getStorageSync('events')
            if (events) {
                const eventList = JSON.parse(events)
                console.log(`从本地存储加载${eventList.length}个日程提醒`)
                eventList.forEach(event => {
                    this.addEventReminder(event)
                })
            }
        } catch (error) {
            console.error('从本地存储初始化日程提醒失败:', error)
        }
        
        // 初始化任务提醒
        try {
            const tasks = uni.getStorageSync('tasks')
            if (tasks) {
                const taskList = JSON.parse(tasks)
                console.log(`从本地存储加载${taskList.length}个任务提醒`)
                taskList.forEach(task => {
                    if (!task.completed) {
                        // 确保移除可能存在的旧提醒
                        this.removeReminder(task.id, 'task')
                        this.removeReminder(task.id, 'task_early')
                        this.removeReminder(task.id, 'task_final')
                        // 添加新提醒机制
                        this.addTaskReminder(task)
                    }
                })
            }
        } catch (error) {
            console.error('从本地存储初始化任务提醒失败:', error)
        }
    }
    
    // 格式化日期为YYYY-MM-DD格式
    formatDate(date) {
        const year = date.getFullYear()
        const month = (date.getMonth() + 1).toString().padStart(2, '0')
        const day = date.getDate().toString().padStart(2, '0')
        return `${year}-${month}-${day}`
    }

    // 清除所有提醒
    clearAllReminders() {
        console.log('清除所有提醒...')
        this.reminders.forEach((timerId, key) => {
            clearTimeout(timerId)
        })
        this.reminders.clear()
        this.notificationQueue = []
    }
}

// 导出单例实例
export const reminderManager = new ReminderManager() 